home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / share / initramfs-tools / scripts / casper-helpers < prev    next >
Text File  |  2009-07-17  |  7KB  |  236 lines
  1. ## Casper helper functions, used by casper on boot and by casper-snapshot
  2.  
  3. if [ "${BUILD_SYSTEM}" = "Debian" ] || [ "${BUILD_SYSTEM}" = "Ubuntu" ]; then
  4.     MP_QUIET="-q"
  5. else
  6.     MP_QUIET=""
  7. fi
  8.  
  9. if [ ! -x "/bin/fstype" ]; then
  10.     # klibc not in path -> not in initramfs
  11.     export PATH="${PATH}:/usr/lib/klibc/bin"
  12. fi
  13.  
  14. sys2dev() {
  15.     sysdev=${1#/sys}
  16.     echo "/dev/$(/sbin/udevadm info -q name -p ${sysdev} 2>/dev/null|| echo ${sysdev##*/})"
  17. }
  18.  
  19. subdevices() {
  20.     sysblock=$1
  21.     r=""
  22.     for dev in "${sysblock}" "${sysblock}"/*; do
  23.         if [ -e "${dev}/dev" ]; then
  24.             r="${r} ${dev}"
  25.         fi
  26.     done
  27.     echo ${r}
  28. }
  29.  
  30. is_supported_fs () {
  31.     # FIXME: do something better like the scan of supported filesystems
  32.     fstype="${1}"
  33.     case ${fstype} in
  34.         vfat|iso9660|udf|ext2|ext3|ext4|ntfs)
  35.             return 0
  36.             ;;
  37.     esac
  38.     return 1
  39. }
  40.  
  41. get_fstype() {
  42.     local FSTYPE
  43.     local FSSIZE
  44.     eval $(fstype < $1)
  45.     if [ "$FSTYPE" != "unknown" ]; then
  46.         echo $FSTYPE
  47.         return 0
  48.     fi
  49.     /sbin/blkid -s TYPE -o value $1 2>/dev/null
  50. }
  51.  
  52. where_is_mounted() {
  53.     device=$1
  54.     if grep -q "^$device " /proc/mounts; then
  55.         mountpoint="$(grep "^$device " /proc/mounts | awk '{print $2; exit}')"
  56.         grep "^$device " /proc/mounts | read d mountpoint rest
  57.         echo $mountpoint
  58.         return 0
  59.     fi
  60.     return 1
  61. }
  62.  
  63. lastline() {
  64.     while read lines ; do
  65.         line=${lines}
  66.     done
  67.     echo "${line}"
  68. }
  69.  
  70. base_path ()
  71. {
  72.     testpath="${1}"
  73.     mounts="$(awk '{print $2}' /proc/mounts)"
  74.     testpath="$(busybox realpath ${testpath})"
  75.  
  76.     while true ; do
  77.         if echo "${mounts}" | grep -qs "^${testpath}" ; then
  78.             set -- `echo "${mounts}" | grep "^${testpath}" | lastline`
  79.             echo ${1}
  80.             break
  81.         else
  82.             testpath=`dirname $testpath`
  83.         fi
  84.     done
  85. }
  86.  
  87. fs_size ()
  88. {
  89.     # Returns used/free fs kbytes + 5% more
  90.     # You could pass a block device as $1 or the mount point as $2
  91.  
  92.     dev="${1}"
  93.     mountp="${2}"
  94.     used="${3}"
  95.  
  96.     if [ -z "${mountp}" ]; then
  97.         mountp=$(where_is_mounted "${dev}")
  98.         if [ "$?" -gt 0 ]; then
  99.             mountp="/mnt/tmp_fs_size"
  100.             mkdir -p "${mountp}"
  101.             mount -t $(get_fstype "${dev}") -o ro "${dev}" "${mountp}"
  102.             doumount=1
  103.         fi
  104.     fi
  105.  
  106.     if [ "${used}" = "used" ]; then
  107.         size=$(du -ks ${mountp} | cut -f1)
  108.         size=$(expr ${size} + ${size} / 20 ) # FIXME: 5% more to be sure
  109.     else
  110.         # free space
  111.         size="$(df -k | grep -s ${mountp} | awk '{print $4}')"
  112.     fi
  113.  
  114.     if [ -n "${doumount}" ]; then
  115.         umount "${mountp}"
  116.         rmdir "${mountp}"
  117.     fi
  118.     echo "${size}"
  119. }
  120.  
  121. setup_loop() {
  122.     local fspath=$1
  123.     local module=$2
  124.     local pattern=$3
  125.     local offset=$4
  126.  
  127.     modprobe ${MP_QUIET} -b "$module"
  128.     /sbin/udevadm settle
  129.  
  130.     if [ "$module" = loop ]; then
  131.         if [ ! -e /dev/loop0 ]; then
  132.             # temporary workaround for kernel bug
  133.             for i in 0 1 2 3 4 5 6 7; do
  134.                 mknod "/dev/loop$i" b 7 "$i" || true
  135.             done
  136.         fi
  137.  
  138.         dev="$(losetup -f)"
  139.         if [ "$dev" ]; then
  140.             if [ -n "$offset" ]; then
  141.                 losetup -o "$offset" "$dev" "$fspath"
  142.             else
  143.                 losetup "$dev" "$fspath"
  144.             fi
  145.             echo "$dev"
  146.             return 0
  147.         else
  148.             panic "No loop devices available"
  149.         fi
  150.     else
  151.         for loopdev in $pattern; do
  152.             if [ "$(cat $loopdev/size)" -eq 0 ]; then
  153.                 dev=$(sys2dev "${loopdev}")
  154.                 if [ -n "$offset" ]; then
  155.                     losetup -o "$offset" "$dev" "$fspath"
  156.                 else
  157.                     losetup "$dev" "$fspath"
  158.                 fi
  159.                 echo "$dev"
  160.                 return 0
  161.             fi
  162.         done
  163.         panic "No loop devices available"
  164.     fi
  165. }
  166.  
  167. try_mount ()
  168. {
  169.     dev="${1}"
  170.     mountp="${2}"
  171.     opts="${3}"
  172.  
  173.     if where_is_mounted ${dev} > /dev/null; then
  174.     if [ "${opts}" != "ro" ]; then
  175.         mount -o remount,"${opts}" ${dev} $(where_is_mounted ${dev}) || panic "Remounting failed"
  176.     fi
  177.         mount -o bind $(where_is_mounted ${dev}) ${mountp} || panic "Cannot bind-mount"
  178.     else
  179.         mount -t $(get_fstype "${dev}") -o "${opts}" "${dev}" "${mountp}" || panic "Cannot mount ${dev} on ${mountp}"
  180.     fi
  181. }
  182.  
  183. find_cow_device() {
  184.     pers_label="${1}"
  185.     cow_backing="/${pers_label}-backing"
  186.     for sysblock in $(echo /sys/block/* | tr ' ' '\n' | grep -v loop); do
  187.         for dev in $(subdevices "${sysblock}"); do
  188.             devname=$(sys2dev "${dev}")
  189.             if [ "$(/sbin/blkid -s LABEL -o value $devname 2>/dev/null)" = "${pers_label}" ]; then
  190.                 echo "$devname"
  191.                 return
  192.             # Do not add any filesystem types here that might be able to
  193.             # mount a journalled filesystem and replay the journal. Doing so
  194.             # will cause data loss when a live CD is booted on a system
  195.             # where filesystems are in use by hibernated operating systems.
  196.             elif [ "$(get_fstype ${devname})" = "vfat" ]; then
  197.                 mkdir -p "${cow_backing}"
  198.                 try_mount "${devname}" "${cow_backing}" "rw"
  199.                 if [ -e "${cow_backing}/${pers_label}" ]; then
  200.                     echo $(setup_loop "${cow_backing}/${pers_label}" "loop" "/sys/block/loop*")
  201.                     return 0
  202.                 else
  203.                     umount ${cow_backing}
  204.                 fi
  205.             fi
  206.         done
  207.     done
  208. }
  209.  
  210. find_files()
  211. # return the first of $filenames found on vfat and ext2 devices
  212. # FIXME: merge with above function
  213. {
  214.     filenames="${1}"
  215.     snap_backing="/snap-backing"
  216.     for sysblock in $(echo /sys/block/* | tr ' ' '\n' | grep -v loop); do
  217.         for dev in $(subdevices "${sysblock}"); do
  218.             devname=$(sys2dev "${dev}")
  219.             devfstype="$(get_fstype ${devname})"
  220.             if [ "${devfstype}" = "vfat" ] ||  [ "${devfstype}" = "ext2" ] ; then # FIXME: all supported block devices should be scanned
  221.                 mkdir -p "${snap_backing}"
  222.                 try_mount "${devname}" "${snap_backing}" "ro"
  223.                 for filename in ${filenames}; do
  224.                     if [ -e "${snap_backing}/${filename}" ]; then
  225.                         echo "${devname} ${snap_backing} ${filename}"
  226.                         return 0
  227.                     fi
  228.                 done
  229.                 umount ${snap_backing}
  230.             fi
  231.         done
  232.     done
  233. }
  234.  
  235.  
  236.